#pragma once
#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <unistd.h>

namespace Threadnode
{
	// template<typename T>
	enum class TSTART
	{
		NEW = 1,
		RUNING = 2,
		STOP = 3,
	};
	static int number = 1;
	template <typename T>
	class thread
	{
		using func_t = std::function<void(T)>;

	private:
		static void *mission(void *agse)
		{
			thread<T> *as = static_cast<thread<T> *>(agse);
			as->_fun(as->_data);
			return nullptr;
		}

	public:
		thread(func_t fun, T data) : _fun(fun), _data(data), _status(TSTART::NEW), _joinabl(true)
		{
			_name = "thread->" + std::to_string(number++);
			_pid = getpid();
		}
		bool start()
		{
			if (_status != TSTART::RUNING)
			{
				int n = pthread_create(&_tid, nullptr, mission, this);
				if (n != 0)
				{
					return false;
				}
				_status = TSTART::RUNING;
				return true;
			}
			return false;
		}
		bool stop()
		{
			if (_status == TSTART::RUNING)
			{
				int n = pthread_cancel(_tid);
				if (n != 0)
					return false;
				_status = TSTART::STOP;
				return true;
			}
			return false;
		}
		bool join()
		{
			// 如果线程没分离就要等待
			if (_joinabl)
			{
				int n = pthread_join(_tid, nullptr);
				if (n != 0)
					return false;
				_status = TSTART::STOP;
				return true;
			}
			return false;
		}
		void detach()
		{
			EnableDetach();
			pthread_detach(_tid);
		}
		void EnableDetach() { _joinabl = false; } // 更改为分离状态
		bool ISjoinabl() { return _joinabl; }
		TSTART status() { return _status; }
		pthread_t tid() { return _tid; }
		pid_t pid() { return _pid; }
		std::string name() { return _name; }
		~thread()
		{
		}

	private:
		std::string _name; // 线程名字
		pthread_t _tid;	   // 线程id
		pid_t _pid;		   // 线程所属进程id
		bool _joinabl;	   // 线程是否分离，默认是不分离
		func_t _fun;
		TSTART _status;
		T _data;
	};
}

//------------------------------------------------------------------------------------
// V1
// namespace Threadnode
// {
// 	using func_t = std::function<void()>;
// 	enum class TSTART
// 	{
// 		NEW = 1,
// 		RUNING = 2,
// 		STOP = 3,
// 	};
// 	static int number = 1;
// 	class thread
// 	{
// 	private:
// 		static void *mission(void *agse)
// 		{
// 			thread *as = static_cast<thread *>(agse);
// 			as->_fun();
// 			return nullptr;
// 		}

// 	public:
// 		thread(func_t fun) : _fun(fun), _status(TSTART::NEW), _joinabl(true)
// 		{
// 			_name = "thread->" + std::to_string(number++);
// 			_pid = getpid();
// 		}
// 		bool start()
// 		{
// 			if (_status != TSTART::RUNING)
// 			{
// 				int n = pthread_create(&_tid, nullptr, mission, this);
// 				if (n != 0)
// 				{
// 					return false;
// 				}
// 				_status = TSTART::RUNING;
// 				return true;
// 			}
// 			return false;
// 		}
// 		bool stop()
// 		{
// 			if (_status == TSTART::RUNING)
// 			{
// 				int n = pthread_cancel(_tid);
// 				if (n != 0)
// 					return false;
// 				_status = TSTART::STOP;
// 				return true;
// 			}
// 			return false;
// 		}
// 		bool join()
// 		{
// 			// 如果线程没分离就要等待
// 			if (_joinabl)
// 			{
// 				int n = pthread_join(_tid, nullptr);
// 				if (n != 0)
// 					return false;
// 				_status = TSTART::STOP;
// 				return true;
// 			}
// 			return false;
// 		}
// 		void detach()
// 		{
// 			EnableDetach();
// 			pthread_detach(_tid);
// 		}
// 		void EnableDetach() { _joinabl = false; } // 更改为分离状态
// 		bool ISjoinabl() { return _joinabl; }
// 		TSTART status() { return _status; }
// 		pthread_t tid() { return _tid; }
// 		pid_t pid() { return _pid; }
// 		std::string name() {return _name;}
// 		~thread()
// 		{
// 		}

// 	private:
// 		std::string _name; // 线程名字
// 		pthread_t _tid;	   // 线程id
// 		pid_t _pid;		   // 线程所属进程id
// 		bool _joinabl;	   // 线程是否分离，默认是不分离
// 		func_t _fun;
// 		TSTART _status;
// 	};
// }
